{
    // 继承
    interface Animate {
        name: string;
        age: number;
        sex: boolean;
    }

    interface Person extends Animate {
        study(): void;
    }
    /**
     * 等同于
     * type Person = {
     *  name:string;
     *  age: number;
     *  sex: boolean;
     *  study(): void;
     * }
     */

}
{
    /**
     * 泛型约束: H extends keyof T
     * 使用extends限制K，只能是keyof T联合类型集合中的值
     *  */ 
    type MyPick<T, H extends keyof T> = {
        [key in H]: T[key]
    }
    type Person = {
        name: string;
        age: number;
        email: string;
    };

    type p = MyPick<Person, 'name' | 'age'>

    type Animate<T extends { name:string, age: number }> = {
        [key in keyof T]: T[key]
    }

    type ani = Animate<{name: 'ck', age: 18, sex: true}>

}


// 条件类型: T extends U ? X : Y
{
    // extends：只会继承更加宽泛的联合类型。
    // 特点：属于整体类型的比较
    type Person = {
        name: string;
        age: number;
        email: string;
    };
    // 'name' | 'age' | 'email' 比 'name'类型更加宽泛，所有不存在继承关系
    type Example1 = keyof Person extends "name" ? true : false;  // false
}

{
    // 条件类型的分布式特性
    type A<T, H> = T extends H ? number : boolean;

    type TestA = A<string | true, string>; // string | boolean;

    /**
     * 在泛型中，如果extends左侧是一个联合类型
     * 那么，T将会是这个联合类型中的某一个具体类型，然后去匹配右侧类型，接着T变为这个联合类型的下一个具体类型，如此循环
     * 
     * T extends H ? number : boolean;
     * string | true extends string ? number : boolean;
     * 变为：
     * string extends string ? number : boolean | true extends string ? number : boolean;
     * => number | boolean;
     * 
     */


    // 如果想整体比较，可使用[T]
    type B<T, H> = [T] extends [H] ? number : boolean;

    type TestB = B<string | true, string>;
    // type TestB = boolean; 
}